<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><link rel="stylesheet" type="text/css" href="style.css" /><script type="text/javascript" src="highlight.js"></script></head><body><pre><span class="hs-pragma">{-# LANGUAGE Safe #-}</span><span>
</span><span id="line-2"></span><span>
</span><span id="line-3"></span><span class="hs-comment">-- |</span><span>
</span><span id="line-4"></span><span class="hs-comment">-- Language.Haskell.TH.Lib contains lots of useful helper functions for</span><span>
</span><span id="line-5"></span><span class="hs-comment">-- generating and manipulating Template Haskell terms</span><span>
</span><span id="line-6"></span><span>
</span><span id="line-7"></span><span class="hs-comment">-- Note: this module mostly re-exports functions from</span><span>
</span><span id="line-8"></span><span class="hs-comment">-- Language.Haskell.TH.Lib.Internal, but if a change occurs to Template</span><span>
</span><span id="line-9"></span><span class="hs-comment">-- Haskell which requires breaking the API offered in this module, we opt to</span><span>
</span><span id="line-10"></span><span class="hs-comment">-- copy the old definition here, and make the changes in</span><span>
</span><span id="line-11"></span><span class="hs-comment">-- Language.Haskell.TH.Lib.Internal. This way, we can retain backwards</span><span>
</span><span id="line-12"></span><span class="hs-comment">-- compatibility while still allowing GHC to make changes as it needs.</span><span>
</span><span id="line-13"></span><span>
</span><span id="line-14"></span><span class="hs-keyword">module</span><span> </span><span class="hs-identifier">Language.Haskell.TH.Lib</span><span> </span><span class="hs-special">(</span><span>
</span><span id="line-15"></span><span>    </span><span class="hs-comment">-- All of the exports from this module should</span><span>
</span><span id="line-16"></span><span>    </span><span class="hs-comment">-- be &quot;public&quot; functions.  The main module TH</span><span>
</span><span id="line-17"></span><span>    </span><span class="hs-comment">-- re-exports them all.</span><span>
</span><span id="line-18"></span><span>
</span><span id="line-19"></span><span>    </span><span class="annot"><span class="hs-comment">-- * Library functions</span></span><span>
</span><span id="line-20"></span><span>    </span><span class="annot"><span class="hs-comment">-- ** Abbreviations</span></span><span>
</span><span id="line-21"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#InfoQ"><span class="hs-identifier">InfoQ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#ExpQ"><span class="hs-identifier">ExpQ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#TExpQ"><span class="hs-identifier">TExpQ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#CodeQ"><span class="hs-identifier">CodeQ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#DecQ"><span class="hs-identifier">DecQ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#DecsQ"><span class="hs-identifier">DecsQ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#ConQ"><span class="hs-identifier">ConQ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#TypeQ"><span class="hs-identifier">TypeQ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#KindQ"><span class="hs-identifier">KindQ</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-22"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#TyLitQ"><span class="hs-identifier">TyLitQ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#CxtQ"><span class="hs-identifier">CxtQ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#PredQ"><span class="hs-identifier">PredQ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#DerivClauseQ"><span class="hs-identifier">DerivClauseQ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#MatchQ"><span class="hs-identifier">MatchQ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#ClauseQ"><span class="hs-identifier">ClauseQ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#BodyQ"><span class="hs-identifier">BodyQ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#GuardQ"><span class="hs-identifier">GuardQ</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-23"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#StmtQ"><span class="hs-identifier">StmtQ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#RangeQ"><span class="hs-identifier">RangeQ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#SourceStrictnessQ"><span class="hs-identifier">SourceStrictnessQ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#SourceUnpackednessQ"><span class="hs-identifier">SourceUnpackednessQ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#BangQ"><span class="hs-identifier">BangQ</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-24"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#BangTypeQ"><span class="hs-identifier">BangTypeQ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#VarBangTypeQ"><span class="hs-identifier">VarBangTypeQ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#StrictTypeQ"><span class="hs-identifier">StrictTypeQ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#VarStrictTypeQ"><span class="hs-identifier">VarStrictTypeQ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#FieldExpQ"><span class="hs-identifier">FieldExpQ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#PatQ"><span class="hs-identifier">PatQ</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-25"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#FieldPatQ"><span class="hs-identifier">FieldPatQ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#RuleBndrQ"><span class="hs-identifier">RuleBndrQ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#TySynEqnQ"><span class="hs-identifier">TySynEqnQ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#PatSynDirQ"><span class="hs-identifier">PatSynDirQ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#PatSynArgsQ"><span class="hs-identifier">PatSynArgsQ</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-26"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#FamilyResultSigQ"><span class="hs-identifier">FamilyResultSigQ</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#DerivStrategyQ"><span class="hs-identifier">DerivStrategyQ</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-27"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#TyVarBndrUnit"><span class="hs-identifier">TyVarBndrUnit</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#TyVarBndrSpec"><span class="hs-identifier">TyVarBndrSpec</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-28"></span><span>
</span><span id="line-29"></span><span>    </span><span class="annot"><span class="hs-comment">-- ** Constructors lifted to 'Q'</span></span><span>
</span><span id="line-30"></span><span>    </span><span class="annot"><span class="hs-comment">-- *** Literals</span></span><span>
</span><span id="line-31"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#intPrimL"><span class="hs-identifier">intPrimL</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#wordPrimL"><span class="hs-identifier">wordPrimL</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#floatPrimL"><span class="hs-identifier">floatPrimL</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#doublePrimL"><span class="hs-identifier">doublePrimL</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#integerL"><span class="hs-identifier">integerL</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#rationalL"><span class="hs-identifier">rationalL</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-32"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#charL"><span class="hs-identifier">charL</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#stringL"><span class="hs-identifier">stringL</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#stringPrimL"><span class="hs-identifier">stringPrimL</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#charPrimL"><span class="hs-identifier">charPrimL</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#bytesPrimL"><span class="hs-identifier">bytesPrimL</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.html#mkBytes"><span class="hs-identifier">mkBytes</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-33"></span><span>    </span><span class="annot"><span class="hs-comment">-- *** Patterns</span></span><span>
</span><span id="line-34"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#litP"><span class="hs-identifier">litP</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#varP"><span class="hs-identifier">varP</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#tupP"><span class="hs-identifier">tupP</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#unboxedTupP"><span class="hs-identifier">unboxedTupP</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#unboxedSumP"><span class="hs-identifier">unboxedSumP</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#conP"><span class="hs-identifier">conP</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#uInfixP"><span class="hs-identifier">uInfixP</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#parensP"><span class="hs-identifier">parensP</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-35"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#infixP"><span class="hs-identifier">infixP</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#tildeP"><span class="hs-identifier">tildeP</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#bangP"><span class="hs-identifier">bangP</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#asP"><span class="hs-identifier">asP</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#wildP"><span class="hs-identifier">wildP</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#recP"><span class="hs-identifier">recP</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-36"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#listP"><span class="hs-identifier">listP</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#sigP"><span class="hs-identifier">sigP</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#viewP"><span class="hs-identifier">viewP</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-37"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#fieldPat"><span class="hs-identifier">fieldPat</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-38"></span><span>
</span><span id="line-39"></span><span>    </span><span class="annot"><span class="hs-comment">-- *** Pattern Guards</span></span><span>
</span><span id="line-40"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#normalB"><span class="hs-identifier">normalB</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#guardedB"><span class="hs-identifier">guardedB</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#normalG"><span class="hs-identifier">normalG</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#normalGE"><span class="hs-identifier">normalGE</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#patG"><span class="hs-identifier">patG</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#patGE"><span class="hs-identifier">patGE</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#match"><span class="hs-identifier">match</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#clause"><span class="hs-identifier">clause</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-41"></span><span>
</span><span id="line-42"></span><span>    </span><span class="annot"><span class="hs-comment">-- *** Expressions</span></span><span>
</span><span id="line-43"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#dyn"><span class="hs-identifier">dyn</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#varE"><span class="hs-identifier">varE</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#unboundVarE"><span class="hs-identifier">unboundVarE</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#labelE"><span class="hs-identifier">labelE</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#implicitParamVarE"><span class="hs-identifier">implicitParamVarE</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#conE"><span class="hs-identifier">conE</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#litE"><span class="hs-identifier">litE</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#staticE"><span class="hs-identifier">staticE</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-44"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#appE"><span class="hs-identifier">appE</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#appTypeE"><span class="hs-identifier">appTypeE</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#uInfixE"><span class="hs-identifier">uInfixE</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#parensE"><span class="hs-identifier">parensE</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#infixE"><span class="hs-identifier">infixE</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#infixApp"><span class="hs-identifier">infixApp</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#sectionL"><span class="hs-identifier">sectionL</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#sectionR"><span class="hs-identifier">sectionR</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-45"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#lamE"><span class="hs-identifier">lamE</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#lam1E"><span class="hs-identifier">lam1E</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#lamCaseE"><span class="hs-identifier">lamCaseE</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.html#tupE"><span class="hs-identifier">tupE</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.html#unboxedTupE"><span class="hs-identifier">unboxedTupE</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#unboxedSumE"><span class="hs-identifier">unboxedSumE</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#condE"><span class="hs-identifier">condE</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#multiIfE"><span class="hs-identifier">multiIfE</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-46"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#letE"><span class="hs-identifier">letE</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#caseE"><span class="hs-identifier">caseE</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#appsE"><span class="hs-identifier">appsE</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#listE"><span class="hs-identifier">listE</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#sigE"><span class="hs-identifier">sigE</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#recConE"><span class="hs-identifier">recConE</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#recUpdE"><span class="hs-identifier">recUpdE</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#stringE"><span class="hs-identifier">stringE</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#fieldExp"><span class="hs-identifier">fieldExp</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-47"></span><span>    </span><span class="annot"><span class="hs-comment">-- **** Ranges</span></span><span>
</span><span id="line-48"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#fromE"><span class="hs-identifier">fromE</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#fromThenE"><span class="hs-identifier">fromThenE</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#fromToE"><span class="hs-identifier">fromToE</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#fromThenToE"><span class="hs-identifier">fromThenToE</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-49"></span><span>
</span><span id="line-50"></span><span>    </span><span class="annot"><span class="hs-comment">-- ***** Ranges with more indirection</span></span><span>
</span><span id="line-51"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#arithSeqE"><span class="hs-identifier">arithSeqE</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-52"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#fromR"><span class="hs-identifier">fromR</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#fromThenR"><span class="hs-identifier">fromThenR</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#fromToR"><span class="hs-identifier">fromToR</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#fromThenToR"><span class="hs-identifier">fromThenToR</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-53"></span><span>    </span><span class="annot"><span class="hs-comment">-- **** Statements</span></span><span>
</span><span id="line-54"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.html#doE"><span class="hs-identifier">doE</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.html#mdoE"><span class="hs-identifier">mdoE</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#compE"><span class="hs-identifier">compE</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-55"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#bindS"><span class="hs-identifier">bindS</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#letS"><span class="hs-identifier">letS</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#noBindS"><span class="hs-identifier">noBindS</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#parS"><span class="hs-identifier">parS</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#recS"><span class="hs-identifier">recS</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-56"></span><span>
</span><span id="line-57"></span><span>    </span><span class="annot"><span class="hs-comment">-- *** Types</span></span><span>
</span><span id="line-58"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.Lib.html#forallT"><span class="hs-identifier">forallT</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#forallVisT"><span class="hs-identifier">forallVisT</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#varT"><span class="hs-identifier">varT</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#conT"><span class="hs-identifier">conT</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#appT"><span class="hs-identifier">appT</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#appKindT"><span class="hs-identifier">appKindT</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#arrowT"><span class="hs-identifier">arrowT</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#infixT"><span class="hs-identifier">infixT</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-59"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#mulArrowT"><span class="hs-identifier">mulArrowT</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-60"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#uInfixT"><span class="hs-identifier">uInfixT</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#parensT"><span class="hs-identifier">parensT</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#equalityT"><span class="hs-identifier">equalityT</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#listT"><span class="hs-identifier">listT</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#tupleT"><span class="hs-identifier">tupleT</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#unboxedTupleT"><span class="hs-identifier">unboxedTupleT</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#unboxedSumT"><span class="hs-identifier">unboxedSumT</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-61"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.Lib.html#sigT"><span class="hs-identifier">sigT</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#litT"><span class="hs-identifier">litT</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#wildCardT"><span class="hs-identifier">wildCardT</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#promotedT"><span class="hs-identifier">promotedT</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#promotedTupleT"><span class="hs-identifier">promotedTupleT</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#promotedNilT"><span class="hs-identifier">promotedNilT</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-62"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#promotedConsT"><span class="hs-identifier">promotedConsT</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#implicitParamT"><span class="hs-identifier">implicitParamT</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-63"></span><span>    </span><span class="annot"><span class="hs-comment">-- **** Type literals</span></span><span>
</span><span id="line-64"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#numTyLit"><span class="hs-identifier">numTyLit</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#strTyLit"><span class="hs-identifier">strTyLit</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-65"></span><span>    </span><span class="annot"><span class="hs-comment">-- **** Strictness</span></span><span>
</span><span id="line-66"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#noSourceUnpackedness"><span class="hs-identifier">noSourceUnpackedness</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#sourceNoUnpack"><span class="hs-identifier">sourceNoUnpack</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#sourceUnpack"><span class="hs-identifier">sourceUnpack</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-67"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#noSourceStrictness"><span class="hs-identifier">noSourceStrictness</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#sourceLazy"><span class="hs-identifier">sourceLazy</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#sourceStrict"><span class="hs-identifier">sourceStrict</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-68"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#isStrict"><span class="hs-identifier">isStrict</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#notStrict"><span class="hs-identifier">notStrict</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#unpacked"><span class="hs-identifier">unpacked</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-69"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#bang"><span class="hs-identifier">bang</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#bangType"><span class="hs-identifier">bangType</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#varBangType"><span class="hs-identifier">varBangType</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#strictType"><span class="hs-identifier">strictType</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#varStrictType"><span class="hs-identifier">varStrictType</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-70"></span><span>    </span><span class="annot"><span class="hs-comment">-- **** Class Contexts</span></span><span>
</span><span id="line-71"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#cxt"><span class="hs-identifier">cxt</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#classP"><span class="hs-identifier">classP</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#equalP"><span class="hs-identifier">equalP</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-72"></span><span>    </span><span class="annot"><span class="hs-comment">-- **** Constructors</span></span><span>
</span><span id="line-73"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#normalC"><span class="hs-identifier">normalC</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#recC"><span class="hs-identifier">recC</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#infixC"><span class="hs-identifier">infixC</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.html#forallC"><span class="hs-identifier">forallC</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#gadtC"><span class="hs-identifier">gadtC</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#recGadtC"><span class="hs-identifier">recGadtC</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-74"></span><span>
</span><span id="line-75"></span><span>    </span><span class="annot"><span class="hs-comment">-- *** Kinds</span></span><span>
</span><span id="line-76"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#varK"><span class="hs-identifier">varK</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#conK"><span class="hs-identifier">conK</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#tupleK"><span class="hs-identifier">tupleK</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#arrowK"><span class="hs-identifier">arrowK</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#listK"><span class="hs-identifier">listK</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#appK"><span class="hs-identifier">appK</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.html#starK"><span class="hs-identifier">starK</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.html#constraintK"><span class="hs-identifier">constraintK</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-77"></span><span>
</span><span id="line-78"></span><span>    </span><span class="annot"><span class="hs-comment">-- *** Type variable binders</span></span><span>
</span><span id="line-79"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.html#plainTV"><span class="hs-identifier">plainTV</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.html#kindedTV"><span class="hs-identifier">kindedTV</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-80"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#plainInvisTV"><span class="hs-identifier">plainInvisTV</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#kindedInvisTV"><span class="hs-identifier">kindedInvisTV</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-81"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#specifiedSpec"><span class="hs-identifier">specifiedSpec</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#inferredSpec"><span class="hs-identifier">inferredSpec</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-82"></span><span>
</span><span id="line-83"></span><span>    </span><span class="annot"><span class="hs-comment">-- *** Roles</span></span><span>
</span><span id="line-84"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#nominalR"><span class="hs-identifier">nominalR</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#representationalR"><span class="hs-identifier">representationalR</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#phantomR"><span class="hs-identifier">phantomR</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#inferR"><span class="hs-identifier">inferR</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-85"></span><span>
</span><span id="line-86"></span><span>    </span><span class="annot"><span class="hs-comment">-- *** Top Level Declarations</span></span><span>
</span><span id="line-87"></span><span>    </span><span class="annot"><span class="hs-comment">-- **** Data</span></span><span>
</span><span id="line-88"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#valD"><span class="hs-identifier">valD</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#funD"><span class="hs-identifier">funD</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.html#tySynD"><span class="hs-identifier">tySynD</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.html#dataD"><span class="hs-identifier">dataD</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.html#newtypeD"><span class="hs-identifier">newtypeD</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-89"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.html#derivClause"><span class="hs-identifier">derivClause</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#DerivClause"><span class="hs-identifier">DerivClause</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span>
</span><span id="line-90"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#stockStrategy"><span class="hs-identifier">stockStrategy</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#anyclassStrategy"><span class="hs-identifier">anyclassStrategy</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#newtypeStrategy"><span class="hs-identifier">newtypeStrategy</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-91"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#viaStrategy"><span class="hs-identifier">viaStrategy</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#DerivStrategy"><span class="hs-identifier">DerivStrategy</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span>
</span><span id="line-92"></span><span>    </span><span class="annot"><span class="hs-comment">-- **** Class</span></span><span>
</span><span id="line-93"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.html#classD"><span class="hs-identifier">classD</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#instanceD"><span class="hs-identifier">instanceD</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#instanceWithOverlapD"><span class="hs-identifier">instanceWithOverlapD</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Overlap"><span class="hs-identifier">Overlap</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span>
</span><span id="line-94"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#sigD"><span class="hs-identifier">sigD</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#kiSigD"><span class="hs-identifier">kiSigD</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#standaloneDerivD"><span class="hs-identifier">standaloneDerivD</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.html#standaloneDerivWithStrategyD"><span class="hs-identifier">standaloneDerivWithStrategyD</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#defaultSigD"><span class="hs-identifier">defaultSigD</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-95"></span><span>
</span><span id="line-96"></span><span>    </span><span class="annot"><span class="hs-comment">-- **** Role annotations</span></span><span>
</span><span id="line-97"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#roleAnnotD"><span class="hs-identifier">roleAnnotD</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-98"></span><span>    </span><span class="annot"><span class="hs-comment">-- **** Type Family / Data Family</span></span><span>
</span><span id="line-99"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.html#dataFamilyD"><span class="hs-identifier">dataFamilyD</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.html#openTypeFamilyD"><span class="hs-identifier">openTypeFamilyD</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.html#closedTypeFamilyD"><span class="hs-identifier">closedTypeFamilyD</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.html#dataInstD"><span class="hs-identifier">dataInstD</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-100"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.html#newtypeInstD"><span class="hs-identifier">newtypeInstD</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#tySynInstD"><span class="hs-identifier">tySynInstD</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-101"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.html#tySynEqn"><span class="hs-identifier">tySynEqn</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#injectivityAnn"><span class="hs-identifier">injectivityAnn</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.html#noSig"><span class="hs-identifier">noSig</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.html#kindSig"><span class="hs-identifier">kindSig</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.html#tyVarSig"><span class="hs-identifier">tyVarSig</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-102"></span><span>
</span><span id="line-103"></span><span>    </span><span class="annot"><span class="hs-comment">-- **** Fixity</span></span><span>
</span><span id="line-104"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#infixLD"><span class="hs-identifier">infixLD</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#infixRD"><span class="hs-identifier">infixRD</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#infixND"><span class="hs-identifier">infixND</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-105"></span><span>
</span><span id="line-106"></span><span>    </span><span class="annot"><span class="hs-comment">-- **** Foreign Function Interface (FFI)</span></span><span>
</span><span id="line-107"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#cCall"><span class="hs-identifier">cCall</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#stdCall"><span class="hs-identifier">stdCall</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#cApi"><span class="hs-identifier">cApi</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#prim"><span class="hs-keyword">prim</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#javaScript"><span class="hs-identifier">javaScript</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-108"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#unsafe"><span class="hs-keyword">unsafe</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#safe"><span class="hs-keyword">safe</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#interruptible"><span class="hs-identifier">interruptible</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#forImpD"><span class="hs-identifier">forImpD</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-109"></span><span>
</span><span id="line-110"></span><span>    </span><span class="annot"><span class="hs-comment">-- **** Functional dependencies</span></span><span>
</span><span id="line-111"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#funDep"><span class="hs-identifier">funDep</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-112"></span><span>
</span><span id="line-113"></span><span>    </span><span class="annot"><span class="hs-comment">-- **** Pragmas</span></span><span>
</span><span id="line-114"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#ruleVar"><span class="hs-identifier">ruleVar</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#typedRuleVar"><span class="hs-identifier">typedRuleVar</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-115"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#valueAnnotation"><span class="hs-identifier">valueAnnotation</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#typeAnnotation"><span class="hs-identifier">typeAnnotation</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#moduleAnnotation"><span class="hs-identifier">moduleAnnotation</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-116"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#pragInlD"><span class="hs-identifier">pragInlD</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#pragSpecD"><span class="hs-identifier">pragSpecD</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#pragSpecInlD"><span class="hs-identifier">pragSpecInlD</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#pragSpecInstD"><span class="hs-identifier">pragSpecInstD</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.html#pragRuleD"><span class="hs-identifier">pragRuleD</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#pragAnnD"><span class="hs-identifier">pragAnnD</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-117"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#pragLineD"><span class="hs-identifier">pragLineD</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#pragCompleteD"><span class="hs-identifier">pragCompleteD</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-118"></span><span>
</span><span id="line-119"></span><span>    </span><span class="annot"><span class="hs-comment">-- **** Pattern Synonyms</span></span><span>
</span><span id="line-120"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#patSynD"><span class="hs-identifier">patSynD</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#patSynSigD"><span class="hs-identifier">patSynSigD</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#unidir"><span class="hs-identifier">unidir</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#implBidir"><span class="hs-identifier">implBidir</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#explBidir"><span class="hs-identifier">explBidir</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#prefixPatSyn"><span class="hs-identifier">prefixPatSyn</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-121"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#infixPatSyn"><span class="hs-identifier">infixPatSyn</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#recordPatSyn"><span class="hs-identifier">recordPatSyn</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-122"></span><span>
</span><span id="line-123"></span><span>    </span><span class="annot"><span class="hs-comment">-- **** Implicit Parameters</span></span><span>
</span><span id="line-124"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#implicitParamBindD"><span class="hs-identifier">implicitParamBindD</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-125"></span><span>
</span><span id="line-126"></span><span>    </span><span class="annot"><span class="hs-comment">-- ** Reify</span></span><span>
</span><span id="line-127"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#thisModule"><span class="hs-identifier">thisModule</span></a></span><span>
</span><span id="line-128"></span><span>
</span><span id="line-129"></span><span>   </span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-130"></span><span>
</span><span id="line-131"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html"><span class="hs-identifier">Language.Haskell.TH.Lib.Internal</span></a></span><span> </span><span class="hs-keyword">hiding</span><span>
</span><span id="line-132"></span><span>  </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#tySynD"><span class="hs-identifier">tySynD</span></a></span><span>
</span><span id="line-133"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#dataD"><span class="hs-identifier">dataD</span></a></span><span>
</span><span id="line-134"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#newtypeD"><span class="hs-identifier">newtypeD</span></a></span><span>
</span><span id="line-135"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#classD"><span class="hs-identifier">classD</span></a></span><span>
</span><span id="line-136"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#pragRuleD"><span class="hs-identifier">pragRuleD</span></a></span><span>
</span><span id="line-137"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#dataInstD"><span class="hs-identifier">dataInstD</span></a></span><span>
</span><span id="line-138"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#newtypeInstD"><span class="hs-identifier">newtypeInstD</span></a></span><span>
</span><span id="line-139"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#dataFamilyD"><span class="hs-identifier">dataFamilyD</span></a></span><span>
</span><span id="line-140"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#openTypeFamilyD"><span class="hs-identifier">openTypeFamilyD</span></a></span><span>
</span><span id="line-141"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#closedTypeFamilyD"><span class="hs-identifier">closedTypeFamilyD</span></a></span><span>
</span><span id="line-142"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#tySynEqn"><span class="hs-identifier">tySynEqn</span></a></span><span>
</span><span id="line-143"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#forallC"><span class="hs-identifier">forallC</span></a></span><span>
</span><span id="line-144"></span><span>
</span><span id="line-145"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#forallT"><span class="hs-identifier">forallT</span></a></span><span>
</span><span id="line-146"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#sigT"><span class="hs-identifier">sigT</span></a></span><span>
</span><span id="line-147"></span><span>
</span><span id="line-148"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#plainTV"><span class="hs-identifier">plainTV</span></a></span><span>
</span><span id="line-149"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#kindedTV"><span class="hs-identifier">kindedTV</span></a></span><span>
</span><span id="line-150"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#starK"><span class="hs-identifier">starK</span></a></span><span>
</span><span id="line-151"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#constraintK"><span class="hs-identifier">constraintK</span></a></span><span>
</span><span id="line-152"></span><span>
</span><span id="line-153"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#noSig"><span class="hs-identifier">noSig</span></a></span><span>
</span><span id="line-154"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#kindSig"><span class="hs-identifier">kindSig</span></a></span><span>
</span><span id="line-155"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#tyVarSig"><span class="hs-identifier">tyVarSig</span></a></span><span>
</span><span id="line-156"></span><span>
</span><span id="line-157"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#derivClause"><span class="hs-identifier">derivClause</span></a></span><span>
</span><span id="line-158"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#standaloneDerivWithStrategyD"><span class="hs-identifier">standaloneDerivWithStrategyD</span></a></span><span>
</span><span id="line-159"></span><span>
</span><span id="line-160"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#doE"><span class="hs-identifier">doE</span></a></span><span>
</span><span id="line-161"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#mdoE"><span class="hs-identifier">mdoE</span></a></span><span>
</span><span id="line-162"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#tupE"><span class="hs-identifier">tupE</span></a></span><span>
</span><span id="line-163"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#unboxedTupE"><span class="hs-identifier">unboxedTupE</span></a></span><span>
</span><span id="line-164"></span><span>
</span><span id="line-165"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#Role"><span class="hs-identifier">Role</span></a></span><span>
</span><span id="line-166"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html#InjectivityAnn"><span class="hs-identifier">InjectivityAnn</span></a></span><span>
</span><span id="line-167"></span><span>  </span><span class="hs-special">)</span><span>
</span><span id="line-168"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Internal.html"><span class="hs-identifier">Language.Haskell.TH.Lib.Internal</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">Internal</span></span><span>
</span><span id="line-169"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html"><span class="hs-identifier">Language.Haskell.TH.Syntax</span></a></span><span>
</span><span id="line-170"></span><span>
</span><span id="line-171"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Control.Applicative.html#"><span class="hs-identifier">Control.Applicative</span></a></span><span> </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#liftA2"><span class="hs-identifier">liftA2</span></a></span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-172"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Foreign.ForeignPtr.html#"><span class="hs-identifier">Foreign.ForeignPtr</span></a></span><span>
</span><span id="line-173"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Word.html#"><span class="hs-identifier">Data.Word</span></a></span><span>
</span><span id="line-174"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Prelude.html#"><span class="hs-identifier">Prelude</span></a></span><span>
</span><span id="line-175"></span><span>
</span><span id="line-176"></span><span class="hs-comment">-- All definitions below represent the &quot;old&quot; API, since their definitions are</span><span>
</span><span id="line-177"></span><span class="hs-comment">-- different in Language.Haskell.TH.Lib.Internal. Please think carefully before</span><span>
</span><span id="line-178"></span><span class="hs-comment">-- deciding to change the APIs of the functions below, as they represent the</span><span>
</span><span id="line-179"></span><span class="hs-comment">-- public API (as opposed to the Internal module, which has no API promises.)</span><span>
</span><span id="line-180"></span><span>
</span><span id="line-181"></span><span class="hs-comment">-------------------------------------------------------------------------------</span><span>
</span><span id="line-182"></span><span class="hs-comment">-- *   Dec</span><span>
</span><span id="line-183"></span><span>
</span><span id="line-184"></span><span id="local-6989586621679167721"><span class="annot"><a href="Language.Haskell.TH.Lib.html#tySynD"><span class="hs-identifier hs-type">tySynD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167721"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167721"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167721"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-185"></span><span id="tySynD"><span class="annot"><span class="annottext">tySynD :: forall (m :: * -&gt; *).
Quote m =&gt;
Name -&gt; [TyVarBndr ()] -&gt; m Type -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.html#tySynD"><span class="hs-identifier hs-var hs-var">tySynD</span></a></span></span><span> </span><span id="local-6989586621679167548"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679167548"><span class="hs-identifier hs-var">tc</span></a></span></span><span> </span><span id="local-6989586621679167547"><span class="annot"><span class="annottext">[TyVarBndr ()]
</span><a href="#local-6989586621679167547"><span class="hs-identifier hs-var">tvs</span></a></span></span><span> </span><span id="local-6989586621679167546"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679167546"><span class="hs-identifier hs-var">rhs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679167545"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679167545"><span class="hs-identifier hs-var">rhs1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679167546"><span class="hs-identifier hs-var">rhs</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Name -&gt; [TyVarBndr ()] -&gt; Type -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#TySynD"><span class="hs-identifier hs-var">TySynD</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679167548"><span class="hs-identifier hs-var">tc</span></a></span><span> </span><span class="annot"><span class="annottext">[TyVarBndr ()]
</span><a href="#local-6989586621679167547"><span class="hs-identifier hs-var">tvs</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679167545"><span class="hs-identifier hs-var">rhs1</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-186"></span><span>
</span><span id="line-187"></span><span id="local-6989586621679167715"><span class="annot"><a href="Language.Haskell.TH.Lib.html#dataD"><span class="hs-identifier hs-type">dataD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167715"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167715"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Cxt"><span class="hs-identifier hs-type">Cxt</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Kind"><span class="hs-identifier hs-type">Kind</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167715"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Con"><span class="hs-identifier hs-type">Con</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167715"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#DerivClause"><span class="hs-identifier hs-type">DerivClause</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-188"></span><span>      </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167715"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-189"></span><span id="dataD"><span class="annot"><span class="annottext">dataD :: forall (m :: * -&gt; *).
Quote m =&gt;
m Cxt
-&gt; Name
-&gt; [TyVarBndr ()]
-&gt; Maybe Type
-&gt; [m Con]
-&gt; [m DerivClause]
-&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.html#dataD"><span class="hs-identifier hs-var hs-var">dataD</span></a></span></span><span> </span><span id="local-6989586621679167530"><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679167530"><span class="hs-identifier hs-var">ctxt</span></a></span></span><span> </span><span id="local-6989586621679167529"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679167529"><span class="hs-identifier hs-var">tc</span></a></span></span><span> </span><span id="local-6989586621679167528"><span class="annot"><span class="annottext">[TyVarBndr ()]
</span><a href="#local-6989586621679167528"><span class="hs-identifier hs-var">tvs</span></a></span></span><span> </span><span id="local-6989586621679167527"><span class="annot"><span class="annottext">Maybe Type
</span><a href="#local-6989586621679167527"><span class="hs-identifier hs-var">ksig</span></a></span></span><span> </span><span id="local-6989586621679167526"><span class="annot"><span class="annottext">[m Con]
</span><a href="#local-6989586621679167526"><span class="hs-identifier hs-var">cons</span></a></span></span><span> </span><span id="local-6989586621679167525"><span class="annot"><span class="annottext">[m DerivClause]
</span><a href="#local-6989586621679167525"><span class="hs-identifier hs-var">derivs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-190"></span><span>  </span><span class="hs-keyword">do</span><span>
</span><span id="line-191"></span><span>    </span><span id="local-6989586621679167524"><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679167524"><span class="hs-identifier hs-var">ctxt1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679167530"><span class="hs-identifier hs-var">ctxt</span></a></span><span>
</span><span id="line-192"></span><span>    </span><span id="local-6989586621679167523"><span class="annot"><span class="annottext">[Con]
</span><a href="#local-6989586621679167523"><span class="hs-identifier hs-var">cons1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m Con] -&gt; m [Con]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m Con]
</span><a href="#local-6989586621679167526"><span class="hs-identifier hs-var">cons</span></a></span><span>
</span><span id="line-193"></span><span>    </span><span id="local-6989586621679167521"><span class="annot"><span class="annottext">[DerivClause]
</span><a href="#local-6989586621679167521"><span class="hs-identifier hs-var">derivs1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m DerivClause] -&gt; m [DerivClause]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m DerivClause]
</span><a href="#local-6989586621679167525"><span class="hs-identifier hs-var">derivs</span></a></span><span>
</span><span id="line-194"></span><span>    </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Cxt
-&gt; Name
-&gt; [TyVarBndr ()]
-&gt; Maybe Type
-&gt; [Con]
-&gt; [DerivClause]
-&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#DataD"><span class="hs-identifier hs-var">DataD</span></a></span><span> </span><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679167524"><span class="hs-identifier hs-var">ctxt1</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679167529"><span class="hs-identifier hs-var">tc</span></a></span><span> </span><span class="annot"><span class="annottext">[TyVarBndr ()]
</span><a href="#local-6989586621679167528"><span class="hs-identifier hs-var">tvs</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe Type
</span><a href="#local-6989586621679167527"><span class="hs-identifier hs-var">ksig</span></a></span><span> </span><span class="annot"><span class="annottext">[Con]
</span><a href="#local-6989586621679167523"><span class="hs-identifier hs-var">cons1</span></a></span><span> </span><span class="annot"><span class="annottext">[DerivClause]
</span><a href="#local-6989586621679167521"><span class="hs-identifier hs-var">derivs1</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-195"></span><span>
</span><span id="line-196"></span><span id="local-6989586621679167709"><span class="annot"><a href="Language.Haskell.TH.Lib.html#newtypeD"><span class="hs-identifier hs-type">newtypeD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167709"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167709"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Cxt"><span class="hs-identifier hs-type">Cxt</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Kind"><span class="hs-identifier hs-type">Kind</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167709"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Con"><span class="hs-identifier hs-type">Con</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167709"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#DerivClause"><span class="hs-identifier hs-type">DerivClause</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-197"></span><span>         </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167709"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-198"></span><span id="newtypeD"><span class="annot"><span class="annottext">newtypeD :: forall (m :: * -&gt; *).
Quote m =&gt;
m Cxt
-&gt; Name
-&gt; [TyVarBndr ()]
-&gt; Maybe Type
-&gt; m Con
-&gt; [m DerivClause]
-&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.html#newtypeD"><span class="hs-identifier hs-var hs-var">newtypeD</span></a></span></span><span> </span><span id="local-6989586621679167510"><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679167510"><span class="hs-identifier hs-var">ctxt</span></a></span></span><span> </span><span id="local-6989586621679167509"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679167509"><span class="hs-identifier hs-var">tc</span></a></span></span><span> </span><span id="local-6989586621679167508"><span class="annot"><span class="annottext">[TyVarBndr ()]
</span><a href="#local-6989586621679167508"><span class="hs-identifier hs-var">tvs</span></a></span></span><span> </span><span id="local-6989586621679167507"><span class="annot"><span class="annottext">Maybe Type
</span><a href="#local-6989586621679167507"><span class="hs-identifier hs-var">ksig</span></a></span></span><span> </span><span id="local-6989586621679167506"><span class="annot"><span class="annottext">m Con
</span><a href="#local-6989586621679167506"><span class="hs-identifier hs-var">con</span></a></span></span><span> </span><span id="local-6989586621679167505"><span class="annot"><span class="annottext">[m DerivClause]
</span><a href="#local-6989586621679167505"><span class="hs-identifier hs-var">derivs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-199"></span><span>  </span><span class="hs-keyword">do</span><span>
</span><span id="line-200"></span><span>    </span><span id="local-6989586621679167504"><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679167504"><span class="hs-identifier hs-var">ctxt1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679167510"><span class="hs-identifier hs-var">ctxt</span></a></span><span>
</span><span id="line-201"></span><span>    </span><span id="local-6989586621679167503"><span class="annot"><span class="annottext">Con
</span><a href="#local-6989586621679167503"><span class="hs-identifier hs-var">con1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Con
</span><a href="#local-6989586621679167506"><span class="hs-identifier hs-var">con</span></a></span><span>
</span><span id="line-202"></span><span>    </span><span id="local-6989586621679167502"><span class="annot"><span class="annottext">[DerivClause]
</span><a href="#local-6989586621679167502"><span class="hs-identifier hs-var">derivs1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m DerivClause] -&gt; m [DerivClause]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m DerivClause]
</span><a href="#local-6989586621679167505"><span class="hs-identifier hs-var">derivs</span></a></span><span>
</span><span id="line-203"></span><span>    </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Cxt
-&gt; Name
-&gt; [TyVarBndr ()]
-&gt; Maybe Type
-&gt; Con
-&gt; [DerivClause]
-&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#NewtypeD"><span class="hs-identifier hs-var">NewtypeD</span></a></span><span> </span><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679167504"><span class="hs-identifier hs-var">ctxt1</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679167509"><span class="hs-identifier hs-var">tc</span></a></span><span> </span><span class="annot"><span class="annottext">[TyVarBndr ()]
</span><a href="#local-6989586621679167508"><span class="hs-identifier hs-var">tvs</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe Type
</span><a href="#local-6989586621679167507"><span class="hs-identifier hs-var">ksig</span></a></span><span> </span><span class="annot"><span class="annottext">Con
</span><a href="#local-6989586621679167503"><span class="hs-identifier hs-var">con1</span></a></span><span> </span><span class="annot"><span class="annottext">[DerivClause]
</span><a href="#local-6989586621679167502"><span class="hs-identifier hs-var">derivs1</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-204"></span><span>
</span><span id="line-205"></span><span id="local-6989586621679167707"><span class="annot"><a href="Language.Haskell.TH.Lib.html#classD"><span class="hs-identifier hs-type">classD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167707"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167707"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Cxt"><span class="hs-identifier hs-type">Cxt</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#FunDep"><span class="hs-identifier hs-type">FunDep</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167707"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167707"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-206"></span><span id="classD"><span class="annot"><span class="annottext">classD :: forall (m :: * -&gt; *).
Quote m =&gt;
m Cxt -&gt; Name -&gt; [TyVarBndr ()] -&gt; [FunDep] -&gt; [m Dec] -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.html#classD"><span class="hs-identifier hs-var hs-var">classD</span></a></span></span><span> </span><span id="local-6989586621679167492"><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679167492"><span class="hs-identifier hs-var">ctxt</span></a></span></span><span> </span><span id="local-6989586621679167491"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679167491"><span class="hs-identifier hs-var">cls</span></a></span></span><span> </span><span id="local-6989586621679167490"><span class="annot"><span class="annottext">[TyVarBndr ()]
</span><a href="#local-6989586621679167490"><span class="hs-identifier hs-var">tvs</span></a></span></span><span> </span><span id="local-6989586621679167489"><span class="annot"><span class="annottext">[FunDep]
</span><a href="#local-6989586621679167489"><span class="hs-identifier hs-var">fds</span></a></span></span><span> </span><span id="local-6989586621679167488"><span class="annot"><span class="annottext">[m Dec]
</span><a href="#local-6989586621679167488"><span class="hs-identifier hs-var">decs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-207"></span><span>  </span><span class="hs-keyword">do</span><span>
</span><span id="line-208"></span><span>    </span><span id="local-6989586621679167487"><span class="annot"><span class="annottext">[Dec]
</span><a href="#local-6989586621679167487"><span class="hs-identifier hs-var">decs1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m Dec] -&gt; m [Dec]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m Dec]
</span><a href="#local-6989586621679167488"><span class="hs-identifier hs-var">decs</span></a></span><span>
</span><span id="line-209"></span><span>    </span><span id="local-6989586621679167486"><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679167486"><span class="hs-identifier hs-var">ctxt1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679167492"><span class="hs-identifier hs-var">ctxt</span></a></span><span>
</span><span id="line-210"></span><span>    </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Dec -&gt; m Dec) -&gt; Dec -&gt; m Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Cxt -&gt; Name -&gt; [TyVarBndr ()] -&gt; [FunDep] -&gt; [Dec] -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#ClassD"><span class="hs-identifier hs-var">ClassD</span></a></span><span> </span><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679167486"><span class="hs-identifier hs-var">ctxt1</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679167491"><span class="hs-identifier hs-var">cls</span></a></span><span> </span><span class="annot"><span class="annottext">[TyVarBndr ()]
</span><a href="#local-6989586621679167490"><span class="hs-identifier hs-var">tvs</span></a></span><span> </span><span class="annot"><span class="annottext">[FunDep]
</span><a href="#local-6989586621679167489"><span class="hs-identifier hs-var">fds</span></a></span><span> </span><span class="annot"><span class="annottext">[Dec]
</span><a href="#local-6989586621679167487"><span class="hs-identifier hs-var">decs1</span></a></span><span>
</span><span id="line-211"></span><span>
</span><span id="line-212"></span><span id="local-6989586621679167702"><span class="annot"><a href="Language.Haskell.TH.Lib.html#pragRuleD"><span class="hs-identifier hs-type">pragRuleD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167702"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167702"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#RuleBndr"><span class="hs-identifier hs-type">RuleBndr</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167702"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167702"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Phases"><span class="hs-identifier hs-type">Phases</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167702"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-213"></span><span id="pragRuleD"><span class="annot"><span class="annottext">pragRuleD :: forall (m :: * -&gt; *).
Quote m =&gt;
String -&gt; [m RuleBndr] -&gt; m Exp -&gt; m Exp -&gt; Phases -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.html#pragRuleD"><span class="hs-identifier hs-var hs-var">pragRuleD</span></a></span></span><span> </span><span id="local-6989586621679167475"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679167475"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span id="local-6989586621679167474"><span class="annot"><span class="annottext">[m RuleBndr]
</span><a href="#local-6989586621679167474"><span class="hs-identifier hs-var">bndrs</span></a></span></span><span> </span><span id="local-6989586621679167473"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679167473"><span class="hs-identifier hs-var">lhs</span></a></span></span><span> </span><span id="local-6989586621679167472"><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679167472"><span class="hs-identifier hs-var">rhs</span></a></span></span><span> </span><span id="local-6989586621679167471"><span class="annot"><span class="annottext">Phases
</span><a href="#local-6989586621679167471"><span class="hs-identifier hs-var">phases</span></a></span></span><span>
</span><span id="line-214"></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-215"></span><span>      </span><span id="local-6989586621679167470"><span class="annot"><span class="annottext">[RuleBndr]
</span><a href="#local-6989586621679167470"><span class="hs-identifier hs-var">bndrs1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m RuleBndr] -&gt; m [RuleBndr]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m RuleBndr]
</span><a href="#local-6989586621679167474"><span class="hs-identifier hs-var">bndrs</span></a></span><span>
</span><span id="line-216"></span><span>      </span><span id="local-6989586621679167469"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679167469"><span class="hs-identifier hs-var">lhs1</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679167473"><span class="hs-identifier hs-var">lhs</span></a></span><span>
</span><span id="line-217"></span><span>      </span><span id="local-6989586621679167468"><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679167468"><span class="hs-identifier hs-var">rhs1</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Exp
</span><a href="#local-6989586621679167472"><span class="hs-identifier hs-var">rhs</span></a></span><span>
</span><span id="line-218"></span><span>      </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Dec -&gt; m Dec) -&gt; Dec -&gt; m Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Pragma -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#PragmaD"><span class="hs-identifier hs-var">PragmaD</span></a></span><span> </span><span class="annot"><span class="annottext">(Pragma -&gt; Dec) -&gt; Pragma -&gt; Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">String
-&gt; Maybe [TyVarBndr ()]
-&gt; [RuleBndr]
-&gt; Exp
-&gt; Exp
-&gt; Phases
-&gt; Pragma
</span><a href="Language.Haskell.TH.Syntax.html#RuleP"><span class="hs-identifier hs-var">RuleP</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679167475"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe [TyVarBndr ()]
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span> </span><span class="annot"><span class="annottext">[RuleBndr]
</span><a href="#local-6989586621679167470"><span class="hs-identifier hs-var">bndrs1</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679167469"><span class="hs-identifier hs-var">lhs1</span></a></span><span> </span><span class="annot"><span class="annottext">Exp
</span><a href="#local-6989586621679167468"><span class="hs-identifier hs-var">rhs1</span></a></span><span> </span><span class="annot"><span class="annottext">Phases
</span><a href="#local-6989586621679167471"><span class="hs-identifier hs-var">phases</span></a></span><span>
</span><span id="line-219"></span><span>
</span><span id="line-220"></span><span id="local-6989586621679167697"><span class="annot"><a href="Language.Haskell.TH.Lib.html#dataInstD"><span class="hs-identifier hs-type">dataInstD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167697"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167697"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Cxt"><span class="hs-identifier hs-type">Cxt</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167697"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Kind"><span class="hs-identifier hs-type">Kind</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167697"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Con"><span class="hs-identifier hs-type">Con</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167697"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#DerivClause"><span class="hs-identifier hs-type">DerivClause</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-221"></span><span>          </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167697"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-222"></span><span id="dataInstD"><span class="annot"><span class="annottext">dataInstD :: forall (m :: * -&gt; *).
Quote m =&gt;
m Cxt
-&gt; Name
-&gt; [m Type]
-&gt; Maybe Type
-&gt; [m Con]
-&gt; [m DerivClause]
-&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.html#dataInstD"><span class="hs-identifier hs-var hs-var">dataInstD</span></a></span></span><span> </span><span id="local-6989586621679167449"><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679167449"><span class="hs-identifier hs-var">ctxt</span></a></span></span><span> </span><span id="local-6989586621679167448"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679167448"><span class="hs-identifier hs-var">tc</span></a></span></span><span> </span><span id="local-6989586621679167447"><span class="annot"><span class="annottext">[m Type]
</span><a href="#local-6989586621679167447"><span class="hs-identifier hs-var">tys</span></a></span></span><span> </span><span id="local-6989586621679167446"><span class="annot"><span class="annottext">Maybe Type
</span><a href="#local-6989586621679167446"><span class="hs-identifier hs-var">ksig</span></a></span></span><span> </span><span id="local-6989586621679167445"><span class="annot"><span class="annottext">[m Con]
</span><a href="#local-6989586621679167445"><span class="hs-identifier hs-var">cons</span></a></span></span><span> </span><span id="local-6989586621679167444"><span class="annot"><span class="annottext">[m DerivClause]
</span><a href="#local-6989586621679167444"><span class="hs-identifier hs-var">derivs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-223"></span><span>  </span><span class="hs-keyword">do</span><span>
</span><span id="line-224"></span><span>    </span><span id="local-6989586621679167443"><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679167443"><span class="hs-identifier hs-var">ctxt1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679167449"><span class="hs-identifier hs-var">ctxt</span></a></span><span>
</span><span id="line-225"></span><span>    </span><span id="local-6989586621679167442"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679167442"><span class="hs-identifier hs-var">ty1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(m Type -&gt; m Type -&gt; m Type) -&gt; m Type -&gt; [m Type] -&gt; m Type
forall (t :: * -&gt; *) b a.
Foldable t =&gt;
(b -&gt; a -&gt; b) -&gt; b -&gt; t a -&gt; b
</span><a href="../../base/src/Data.Foldable.html#foldl"><span class="hs-identifier hs-var">foldl</span></a></span><span> </span><span class="annot"><span class="annottext">m Type -&gt; m Type -&gt; m Type
forall (m :: * -&gt; *). Quote m =&gt; m Type -&gt; m Type -&gt; m Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#appT"><span class="hs-identifier hs-var">appT</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Name -&gt; m Type
forall (m :: * -&gt; *). Quote m =&gt; Name -&gt; m Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#conT"><span class="hs-identifier hs-var">conT</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679167448"><span class="hs-identifier hs-var">tc</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">[m Type]
</span><a href="#local-6989586621679167447"><span class="hs-identifier hs-var">tys</span></a></span><span>
</span><span id="line-226"></span><span>    </span><span id="local-6989586621679167440"><span class="annot"><span class="annottext">[Con]
</span><a href="#local-6989586621679167440"><span class="hs-identifier hs-var">cons1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m Con] -&gt; m [Con]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m Con]
</span><a href="#local-6989586621679167445"><span class="hs-identifier hs-var">cons</span></a></span><span>
</span><span id="line-227"></span><span>    </span><span id="local-6989586621679167439"><span class="annot"><span class="annottext">[DerivClause]
</span><a href="#local-6989586621679167439"><span class="hs-identifier hs-var">derivs1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m DerivClause] -&gt; m [DerivClause]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m DerivClause]
</span><a href="#local-6989586621679167444"><span class="hs-identifier hs-var">derivs</span></a></span><span>
</span><span id="line-228"></span><span>    </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Cxt
-&gt; Maybe [TyVarBndr ()]
-&gt; Type
-&gt; Maybe Type
-&gt; [Con]
-&gt; [DerivClause]
-&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#DataInstD"><span class="hs-identifier hs-var">DataInstD</span></a></span><span> </span><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679167443"><span class="hs-identifier hs-var">ctxt1</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe [TyVarBndr ()]
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679167442"><span class="hs-identifier hs-var">ty1</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe Type
</span><a href="#local-6989586621679167446"><span class="hs-identifier hs-var">ksig</span></a></span><span> </span><span class="annot"><span class="annottext">[Con]
</span><a href="#local-6989586621679167440"><span class="hs-identifier hs-var">cons1</span></a></span><span> </span><span class="annot"><span class="annottext">[DerivClause]
</span><a href="#local-6989586621679167439"><span class="hs-identifier hs-var">derivs1</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-229"></span><span>
</span><span id="line-230"></span><span id="local-6989586621679167690"><span class="annot"><a href="Language.Haskell.TH.Lib.html#newtypeInstD"><span class="hs-identifier hs-type">newtypeInstD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167690"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167690"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Cxt"><span class="hs-identifier hs-type">Cxt</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167690"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Kind"><span class="hs-identifier hs-type">Kind</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167690"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Con"><span class="hs-identifier hs-type">Con</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167690"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#DerivClause"><span class="hs-identifier hs-type">DerivClause</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-231"></span><span>             </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167690"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-232"></span><span id="newtypeInstD"><span class="annot"><span class="annottext">newtypeInstD :: forall (m :: * -&gt; *).
Quote m =&gt;
m Cxt
-&gt; Name
-&gt; [m Type]
-&gt; Maybe Type
-&gt; m Con
-&gt; [m DerivClause]
-&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.html#newtypeInstD"><span class="hs-identifier hs-var hs-var">newtypeInstD</span></a></span></span><span> </span><span id="local-6989586621679167424"><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679167424"><span class="hs-identifier hs-var">ctxt</span></a></span></span><span> </span><span id="local-6989586621679167423"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679167423"><span class="hs-identifier hs-var">tc</span></a></span></span><span> </span><span id="local-6989586621679167422"><span class="annot"><span class="annottext">[m Type]
</span><a href="#local-6989586621679167422"><span class="hs-identifier hs-var">tys</span></a></span></span><span> </span><span id="local-6989586621679167421"><span class="annot"><span class="annottext">Maybe Type
</span><a href="#local-6989586621679167421"><span class="hs-identifier hs-var">ksig</span></a></span></span><span> </span><span id="local-6989586621679167420"><span class="annot"><span class="annottext">m Con
</span><a href="#local-6989586621679167420"><span class="hs-identifier hs-var">con</span></a></span></span><span> </span><span id="local-6989586621679167419"><span class="annot"><span class="annottext">[m DerivClause]
</span><a href="#local-6989586621679167419"><span class="hs-identifier hs-var">derivs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-233"></span><span>  </span><span class="hs-keyword">do</span><span>
</span><span id="line-234"></span><span>    </span><span id="local-6989586621679167418"><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679167418"><span class="hs-identifier hs-var">ctxt1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679167424"><span class="hs-identifier hs-var">ctxt</span></a></span><span>
</span><span id="line-235"></span><span>    </span><span id="local-6989586621679167417"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679167417"><span class="hs-identifier hs-var">ty1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(m Type -&gt; m Type -&gt; m Type) -&gt; m Type -&gt; [m Type] -&gt; m Type
forall (t :: * -&gt; *) b a.
Foldable t =&gt;
(b -&gt; a -&gt; b) -&gt; b -&gt; t a -&gt; b
</span><a href="../../base/src/Data.Foldable.html#foldl"><span class="hs-identifier hs-var">foldl</span></a></span><span> </span><span class="annot"><span class="annottext">m Type -&gt; m Type -&gt; m Type
forall (m :: * -&gt; *). Quote m =&gt; m Type -&gt; m Type -&gt; m Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#appT"><span class="hs-identifier hs-var">appT</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Name -&gt; m Type
forall (m :: * -&gt; *). Quote m =&gt; Name -&gt; m Type
</span><a href="Language.Haskell.TH.Lib.Internal.html#conT"><span class="hs-identifier hs-var">conT</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679167423"><span class="hs-identifier hs-var">tc</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">[m Type]
</span><a href="#local-6989586621679167422"><span class="hs-identifier hs-var">tys</span></a></span><span>
</span><span id="line-236"></span><span>    </span><span id="local-6989586621679167416"><span class="annot"><span class="annottext">Con
</span><a href="#local-6989586621679167416"><span class="hs-identifier hs-var">con1</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Con
</span><a href="#local-6989586621679167420"><span class="hs-identifier hs-var">con</span></a></span><span>
</span><span id="line-237"></span><span>    </span><span id="local-6989586621679167415"><span class="annot"><span class="annottext">[DerivClause]
</span><a href="#local-6989586621679167415"><span class="hs-identifier hs-var">derivs1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m DerivClause] -&gt; m [DerivClause]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m DerivClause]
</span><a href="#local-6989586621679167419"><span class="hs-identifier hs-var">derivs</span></a></span><span>
</span><span id="line-238"></span><span>    </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Cxt
-&gt; Maybe [TyVarBndr ()]
-&gt; Type
-&gt; Maybe Type
-&gt; Con
-&gt; [DerivClause]
-&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#NewtypeInstD"><span class="hs-identifier hs-var">NewtypeInstD</span></a></span><span> </span><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679167418"><span class="hs-identifier hs-var">ctxt1</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe [TyVarBndr ()]
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679167417"><span class="hs-identifier hs-var">ty1</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe Type
</span><a href="#local-6989586621679167421"><span class="hs-identifier hs-var">ksig</span></a></span><span> </span><span class="annot"><span class="annottext">Con
</span><a href="#local-6989586621679167416"><span class="hs-identifier hs-var">con1</span></a></span><span> </span><span class="annot"><span class="annottext">[DerivClause]
</span><a href="#local-6989586621679167415"><span class="hs-identifier hs-var">derivs1</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-239"></span><span>
</span><span id="line-240"></span><span id="local-6989586621679167688"><span class="annot"><a href="Language.Haskell.TH.Lib.html#dataFamilyD"><span class="hs-identifier hs-type">dataFamilyD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167688"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Kind"><span class="hs-identifier hs-type">Kind</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167688"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-241"></span><span id="dataFamilyD"><span class="annot"><span class="annottext">dataFamilyD :: forall (m :: * -&gt; *).
Quote m =&gt;
Name -&gt; [TyVarBndr ()] -&gt; Maybe Type -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.html#dataFamilyD"><span class="hs-identifier hs-var hs-var">dataFamilyD</span></a></span></span><span> </span><span id="local-6989586621679167409"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679167409"><span class="hs-identifier hs-var">tc</span></a></span></span><span> </span><span id="local-6989586621679167408"><span class="annot"><span class="annottext">[TyVarBndr ()]
</span><a href="#local-6989586621679167408"><span class="hs-identifier hs-var">tvs</span></a></span></span><span> </span><span id="local-6989586621679167407"><span class="annot"><span class="annottext">Maybe Type
</span><a href="#local-6989586621679167407"><span class="hs-identifier hs-var">kind</span></a></span></span><span>
</span><span id="line-242"></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Dec -&gt; m Dec) -&gt; Dec -&gt; m Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Name -&gt; [TyVarBndr ()] -&gt; Maybe Type -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#DataFamilyD"><span class="hs-identifier hs-var">DataFamilyD</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679167409"><span class="hs-identifier hs-var">tc</span></a></span><span> </span><span class="annot"><span class="annottext">[TyVarBndr ()]
</span><a href="#local-6989586621679167408"><span class="hs-identifier hs-var">tvs</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe Type
</span><a href="#local-6989586621679167407"><span class="hs-identifier hs-var">kind</span></a></span><span>
</span><span id="line-243"></span><span>
</span><span id="line-244"></span><span id="local-6989586621679167684"><span class="annot"><a href="Language.Haskell.TH.Lib.html#openTypeFamilyD"><span class="hs-identifier hs-type">openTypeFamilyD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167684"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#FamilyResultSig"><span class="hs-identifier hs-type">FamilyResultSig</span></a></span><span>
</span><span id="line-245"></span><span>                </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#InjectivityAnn"><span class="hs-identifier hs-type">InjectivityAnn</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167684"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-246"></span><span id="openTypeFamilyD"><span class="annot"><span class="annottext">openTypeFamilyD :: forall (m :: * -&gt; *).
Quote m =&gt;
Name
-&gt; [TyVarBndr ()]
-&gt; FamilyResultSig
-&gt; Maybe InjectivityAnn
-&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.html#openTypeFamilyD"><span class="hs-identifier hs-var hs-var">openTypeFamilyD</span></a></span></span><span> </span><span id="local-6989586621679167401"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679167401"><span class="hs-identifier hs-var">tc</span></a></span></span><span> </span><span id="local-6989586621679167400"><span class="annot"><span class="annottext">[TyVarBndr ()]
</span><a href="#local-6989586621679167400"><span class="hs-identifier hs-var">tvs</span></a></span></span><span> </span><span id="local-6989586621679167399"><span class="annot"><span class="annottext">FamilyResultSig
</span><a href="#local-6989586621679167399"><span class="hs-identifier hs-var">res</span></a></span></span><span> </span><span id="local-6989586621679167398"><span class="annot"><span class="annottext">Maybe InjectivityAnn
</span><a href="#local-6989586621679167398"><span class="hs-identifier hs-var">inj</span></a></span></span><span>
</span><span id="line-247"></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(Dec -&gt; m Dec) -&gt; Dec -&gt; m Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">TypeFamilyHead -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#OpenTypeFamilyD"><span class="hs-identifier hs-var">OpenTypeFamilyD</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Name
-&gt; [TyVarBndr ()]
-&gt; FamilyResultSig
-&gt; Maybe InjectivityAnn
-&gt; TypeFamilyHead
</span><a href="Language.Haskell.TH.Syntax.html#TypeFamilyHead"><span class="hs-identifier hs-var">TypeFamilyHead</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679167401"><span class="hs-identifier hs-var">tc</span></a></span><span> </span><span class="annot"><span class="annottext">[TyVarBndr ()]
</span><a href="#local-6989586621679167400"><span class="hs-identifier hs-var">tvs</span></a></span><span> </span><span class="annot"><span class="annottext">FamilyResultSig
</span><a href="#local-6989586621679167399"><span class="hs-identifier hs-var">res</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe InjectivityAnn
</span><a href="#local-6989586621679167398"><span class="hs-identifier hs-var">inj</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-248"></span><span>
</span><span id="line-249"></span><span id="local-6989586621679167680"><span class="annot"><a href="Language.Haskell.TH.Lib.html#closedTypeFamilyD"><span class="hs-identifier hs-type">closedTypeFamilyD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167680"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#FamilyResultSig"><span class="hs-identifier hs-type">FamilyResultSig</span></a></span><span>
</span><span id="line-250"></span><span>                  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#InjectivityAnn"><span class="hs-identifier hs-type">InjectivityAnn</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167680"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TySynEqn"><span class="hs-identifier hs-type">TySynEqn</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167680"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-251"></span><span id="closedTypeFamilyD"><span class="annot"><span class="annottext">closedTypeFamilyD :: forall (m :: * -&gt; *).
Quote m =&gt;
Name
-&gt; [TyVarBndr ()]
-&gt; FamilyResultSig
-&gt; Maybe InjectivityAnn
-&gt; [m TySynEqn]
-&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.html#closedTypeFamilyD"><span class="hs-identifier hs-var hs-var">closedTypeFamilyD</span></a></span></span><span> </span><span id="local-6989586621679167388"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679167388"><span class="hs-identifier hs-var">tc</span></a></span></span><span> </span><span id="local-6989586621679167387"><span class="annot"><span class="annottext">[TyVarBndr ()]
</span><a href="#local-6989586621679167387"><span class="hs-identifier hs-var">tvs</span></a></span></span><span> </span><span id="local-6989586621679167386"><span class="annot"><span class="annottext">FamilyResultSig
</span><a href="#local-6989586621679167386"><span class="hs-identifier hs-var">result</span></a></span></span><span> </span><span id="local-6989586621679167385"><span class="annot"><span class="annottext">Maybe InjectivityAnn
</span><a href="#local-6989586621679167385"><span class="hs-identifier hs-var">injectivity</span></a></span></span><span> </span><span id="local-6989586621679167384"><span class="annot"><span class="annottext">[m TySynEqn]
</span><a href="#local-6989586621679167384"><span class="hs-identifier hs-var">eqns</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-252"></span><span>  </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679167383"><span class="annot"><span class="annottext">[TySynEqn]
</span><a href="#local-6989586621679167383"><span class="hs-identifier hs-var">eqns1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m TySynEqn] -&gt; m [TySynEqn]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m TySynEqn]
</span><a href="#local-6989586621679167384"><span class="hs-identifier hs-var">eqns</span></a></span><span>
</span><span id="line-253"></span><span>     </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">TypeFamilyHead -&gt; [TySynEqn] -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#ClosedTypeFamilyD"><span class="hs-identifier hs-var">ClosedTypeFamilyD</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Name
-&gt; [TyVarBndr ()]
-&gt; FamilyResultSig
-&gt; Maybe InjectivityAnn
-&gt; TypeFamilyHead
</span><a href="Language.Haskell.TH.Syntax.html#TypeFamilyHead"><span class="hs-identifier hs-var">TypeFamilyHead</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679167388"><span class="hs-identifier hs-var">tc</span></a></span><span> </span><span class="annot"><span class="annottext">[TyVarBndr ()]
</span><a href="#local-6989586621679167387"><span class="hs-identifier hs-var">tvs</span></a></span><span> </span><span class="annot"><span class="annottext">FamilyResultSig
</span><a href="#local-6989586621679167386"><span class="hs-identifier hs-var">result</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe InjectivityAnn
</span><a href="#local-6989586621679167385"><span class="hs-identifier hs-var">injectivity</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">[TySynEqn]
</span><a href="#local-6989586621679167383"><span class="hs-identifier hs-var">eqns1</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-254"></span><span>
</span><span id="line-255"></span><span id="local-6989586621679167678"><span class="annot"><a href="Language.Haskell.TH.Lib.html#tySynEqn"><span class="hs-identifier hs-type">tySynEqn</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167678"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">]</span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167678"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167678"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167678"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TySynEqn"><span class="hs-identifier hs-type">TySynEqn</span></a></span></span><span>
</span><span id="line-256"></span><span id="tySynEqn"><span class="annot"><span class="annottext">tySynEqn :: forall (m :: * -&gt; *).
Quote m =&gt;
Maybe [TyVarBndr ()] -&gt; m Type -&gt; m Type -&gt; m TySynEqn
</span><a href="Language.Haskell.TH.Lib.html#tySynEqn"><span class="hs-identifier hs-var hs-var">tySynEqn</span></a></span></span><span> </span><span id="local-6989586621679167376"><span class="annot"><span class="annottext">Maybe [TyVarBndr ()]
</span><a href="#local-6989586621679167376"><span class="hs-identifier hs-var">tvs</span></a></span></span><span> </span><span id="local-6989586621679167375"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679167375"><span class="hs-identifier hs-var">lhs</span></a></span></span><span> </span><span id="local-6989586621679167374"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679167374"><span class="hs-identifier hs-var">rhs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-257"></span><span>  </span><span class="hs-keyword">do</span><span>
</span><span id="line-258"></span><span>    </span><span id="local-6989586621679167373"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679167373"><span class="hs-identifier hs-var">lhs1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679167375"><span class="hs-identifier hs-var">lhs</span></a></span><span>
</span><span id="line-259"></span><span>    </span><span id="local-6989586621679167372"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679167372"><span class="hs-identifier hs-var">rhs1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679167374"><span class="hs-identifier hs-var">rhs</span></a></span><span>
</span><span id="line-260"></span><span>    </span><span class="annot"><span class="annottext">TySynEqn -&gt; m TySynEqn
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Maybe [TyVarBndr ()] -&gt; Type -&gt; Type -&gt; TySynEqn
</span><a href="Language.Haskell.TH.Syntax.html#TySynEqn"><span class="hs-identifier hs-var">TySynEqn</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe [TyVarBndr ()]
</span><a href="#local-6989586621679167376"><span class="hs-identifier hs-var">tvs</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679167373"><span class="hs-identifier hs-var">lhs1</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679167372"><span class="hs-identifier hs-var">rhs1</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-261"></span><span>
</span><span id="line-262"></span><span id="local-6989586621679167676"><span class="annot"><a href="Language.Haskell.TH.Lib.html#forallC"><span class="hs-identifier hs-type">forallC</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167676"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Specificity"><span class="hs-identifier hs-type">Specificity</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167676"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Cxt"><span class="hs-identifier hs-type">Cxt</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167676"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Con"><span class="hs-identifier hs-type">Con</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167676"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Con"><span class="hs-identifier hs-type">Con</span></a></span></span><span>
</span><span id="line-263"></span><span id="forallC"><span class="annot"><span class="annottext">forallC :: forall (m :: * -&gt; *).
Quote m =&gt;
[TyVarBndr Specificity] -&gt; m Cxt -&gt; m Con -&gt; m Con
</span><a href="Language.Haskell.TH.Lib.html#forallC"><span class="hs-identifier hs-var hs-var">forallC</span></a></span></span><span> </span><span id="local-6989586621679167366"><span class="annot"><span class="annottext">[TyVarBndr Specificity]
</span><a href="#local-6989586621679167366"><span class="hs-identifier hs-var">ns</span></a></span></span><span> </span><span id="local-6989586621679167365"><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679167365"><span class="hs-identifier hs-var">ctxt</span></a></span></span><span> </span><span id="local-6989586621679167364"><span class="annot"><span class="annottext">m Con
</span><a href="#local-6989586621679167364"><span class="hs-identifier hs-var">con</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Cxt -&gt; Con -&gt; Con) -&gt; m Cxt -&gt; m Con -&gt; m Con
forall (f :: * -&gt; *) a b c.
Applicative f =&gt;
(a -&gt; b -&gt; c) -&gt; f a -&gt; f b -&gt; f c
</span><a href="../../base/src/GHC.Base.html#liftA2"><span class="hs-identifier hs-var">liftA2</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[TyVarBndr Specificity] -&gt; Cxt -&gt; Con -&gt; Con
</span><a href="Language.Haskell.TH.Syntax.html#ForallC"><span class="hs-identifier hs-var">ForallC</span></a></span><span> </span><span class="annot"><span class="annottext">[TyVarBndr Specificity]
</span><a href="#local-6989586621679167366"><span class="hs-identifier hs-var">ns</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679167365"><span class="hs-identifier hs-var">ctxt</span></a></span><span> </span><span class="annot"><span class="annottext">m Con
</span><a href="#local-6989586621679167364"><span class="hs-identifier hs-var">con</span></a></span><span>
</span><span id="line-264"></span><span>
</span><span id="line-265"></span><span class="hs-comment">-------------------------------------------------------------------------------</span><span>
</span><span id="line-266"></span><span class="hs-comment">-- *   Type</span><span>
</span><span id="line-267"></span><span>
</span><span id="line-268"></span><span id="local-6989586621679167670"><span class="annot"><a href="Language.Haskell.TH.Lib.html#forallT"><span class="hs-identifier hs-type">forallT</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167670"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Specificity"><span class="hs-identifier hs-type">Specificity</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167670"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Cxt"><span class="hs-identifier hs-type">Cxt</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167670"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167670"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span></span><span>
</span><span id="line-269"></span><span id="forallT"><span class="annot"><span class="annottext">forallT :: forall (m :: * -&gt; *).
Quote m =&gt;
[TyVarBndr Specificity] -&gt; m Cxt -&gt; m Type -&gt; m Type
</span><a href="Language.Haskell.TH.Lib.html#forallT"><span class="hs-identifier hs-var hs-var">forallT</span></a></span></span><span> </span><span id="local-6989586621679167357"><span class="annot"><span class="annottext">[TyVarBndr Specificity]
</span><a href="#local-6989586621679167357"><span class="hs-identifier hs-var">tvars</span></a></span></span><span> </span><span id="local-6989586621679167356"><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679167356"><span class="hs-identifier hs-var">ctxt</span></a></span></span><span> </span><span id="local-6989586621679167355"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679167355"><span class="hs-identifier hs-var">ty</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-270"></span><span>    </span><span id="local-6989586621679167354"><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679167354"><span class="hs-identifier hs-var">ctxt1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679167356"><span class="hs-identifier hs-var">ctxt</span></a></span><span>
</span><span id="line-271"></span><span>    </span><span id="local-6989586621679167353"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679167353"><span class="hs-identifier hs-var">ty1</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679167355"><span class="hs-identifier hs-var">ty</span></a></span><span>
</span><span id="line-272"></span><span>    </span><span class="annot"><span class="annottext">Type -&gt; m Type
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Type -&gt; m Type) -&gt; Type -&gt; m Type
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">[TyVarBndr Specificity] -&gt; Cxt -&gt; Type -&gt; Type
</span><a href="Language.Haskell.TH.Syntax.html#ForallT"><span class="hs-identifier hs-var">ForallT</span></a></span><span> </span><span class="annot"><span class="annottext">[TyVarBndr Specificity]
</span><a href="#local-6989586621679167357"><span class="hs-identifier hs-var">tvars</span></a></span><span> </span><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679167354"><span class="hs-identifier hs-var">ctxt1</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679167353"><span class="hs-identifier hs-var">ty1</span></a></span><span>
</span><span id="line-273"></span><span>
</span><span id="line-274"></span><span id="local-6989586621679167668"><span class="annot"><a href="Language.Haskell.TH.Lib.html#sigT"><span class="hs-identifier hs-type">sigT</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167668"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167668"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Kind"><span class="hs-identifier hs-type">Kind</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167668"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span></span><span>
</span><span id="line-275"></span><span id="sigT"><span class="annot"><span class="annottext">sigT :: forall (m :: * -&gt; *). Quote m =&gt; m Type -&gt; Type -&gt; m Type
</span><a href="Language.Haskell.TH.Lib.html#sigT"><span class="hs-identifier hs-var hs-var">sigT</span></a></span></span><span> </span><span id="local-6989586621679167347"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679167347"><span class="hs-identifier hs-var">t</span></a></span></span><span> </span><span id="local-6989586621679167346"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679167346"><span class="hs-identifier hs-var">k</span></a></span></span><span>
</span><span id="line-276"></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-277"></span><span>      </span><span id="local-6989586621679167345"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679167345"><span class="hs-identifier hs-var">t'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679167347"><span class="hs-identifier hs-var">t</span></a></span><span>
</span><span id="line-278"></span><span>      </span><span class="annot"><span class="annottext">Type -&gt; m Type
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Type -&gt; m Type) -&gt; Type -&gt; m Type
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Type -&gt; Type -&gt; Type
</span><a href="Language.Haskell.TH.Syntax.html#SigT"><span class="hs-identifier hs-var">SigT</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679167345"><span class="hs-identifier hs-var">t'</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679167346"><span class="hs-identifier hs-var">k</span></a></span><span>
</span><span id="line-279"></span><span>
</span><span id="line-280"></span><span class="hs-comment">-------------------------------------------------------------------------------</span><span>
</span><span id="line-281"></span><span class="hs-comment">-- *   Kind</span><span>
</span><span id="line-282"></span><span>
</span><span id="line-283"></span><span class="annot"><a href="Language.Haskell.TH.Lib.html#plainTV"><span class="hs-identifier hs-type">plainTV</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-284"></span><span id="plainTV"><span class="annot"><span class="annottext">plainTV :: Name -&gt; TyVarBndr ()
</span><a href="Language.Haskell.TH.Lib.html#plainTV"><span class="hs-identifier hs-var hs-var">plainTV</span></a></span></span><span> </span><span id="local-6989586621679167343"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679167343"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Name -&gt; () -&gt; TyVarBndr ()
forall flag. Name -&gt; flag -&gt; TyVarBndr flag
</span><a href="Language.Haskell.TH.Syntax.html#PlainTV"><span class="hs-identifier hs-var">PlainTV</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679167343"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-285"></span><span>
</span><span id="line-286"></span><span class="annot"><a href="Language.Haskell.TH.Lib.html#kindedTV"><span class="hs-identifier hs-type">kindedTV</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Kind"><span class="hs-identifier hs-type">Kind</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-287"></span><span id="kindedTV"><span class="annot"><span class="annottext">kindedTV :: Name -&gt; Type -&gt; TyVarBndr ()
</span><a href="Language.Haskell.TH.Lib.html#kindedTV"><span class="hs-identifier hs-var hs-var">kindedTV</span></a></span></span><span> </span><span id="local-6989586621679167341"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679167341"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span id="local-6989586621679167340"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679167340"><span class="hs-identifier hs-var">k</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Name -&gt; () -&gt; Type -&gt; TyVarBndr ()
forall flag. Name -&gt; flag -&gt; Type -&gt; TyVarBndr flag
</span><a href="Language.Haskell.TH.Syntax.html#KindedTV"><span class="hs-identifier hs-var">KindedTV</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679167341"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679167340"><span class="hs-identifier hs-var">k</span></a></span><span>
</span><span id="line-288"></span><span>
</span><span id="line-289"></span><span class="annot"><a href="Language.Haskell.TH.Lib.html#starK"><span class="hs-identifier hs-type">starK</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Kind"><span class="hs-identifier hs-type">Kind</span></a></span><span>
</span><span id="line-290"></span><span id="starK"><span class="annot"><span class="annottext">starK :: Type
</span><a href="Language.Haskell.TH.Lib.html#starK"><span class="hs-identifier hs-var hs-var">starK</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="Language.Haskell.TH.Syntax.html#StarT"><span class="hs-identifier hs-var">StarT</span></a></span><span>
</span><span id="line-291"></span><span>
</span><span id="line-292"></span><span class="annot"><a href="Language.Haskell.TH.Lib.html#constraintK"><span class="hs-identifier hs-type">constraintK</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Kind"><span class="hs-identifier hs-type">Kind</span></a></span><span>
</span><span id="line-293"></span><span id="constraintK"><span class="annot"><span class="annottext">constraintK :: Type
</span><a href="Language.Haskell.TH.Lib.html#constraintK"><span class="hs-identifier hs-var hs-var">constraintK</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="Language.Haskell.TH.Syntax.html#ConstraintT"><span class="hs-identifier hs-var">ConstraintT</span></a></span><span>
</span><span id="line-294"></span><span>
</span><span id="line-295"></span><span class="hs-comment">-------------------------------------------------------------------------------</span><span>
</span><span id="line-296"></span><span class="hs-comment">-- *   Type family result</span><span>
</span><span id="line-297"></span><span>
</span><span id="line-298"></span><span class="annot"><a href="Language.Haskell.TH.Lib.html#noSig"><span class="hs-identifier hs-type">noSig</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#FamilyResultSig"><span class="hs-identifier hs-type">FamilyResultSig</span></a></span><span>
</span><span id="line-299"></span><span id="noSig"><span class="annot"><span class="annottext">noSig :: FamilyResultSig
</span><a href="Language.Haskell.TH.Lib.html#noSig"><span class="hs-identifier hs-var hs-var">noSig</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">FamilyResultSig
</span><a href="Language.Haskell.TH.Syntax.html#NoSig"><span class="hs-identifier hs-var">NoSig</span></a></span><span>
</span><span id="line-300"></span><span>
</span><span id="line-301"></span><span class="annot"><a href="Language.Haskell.TH.Lib.html#kindSig"><span class="hs-identifier hs-type">kindSig</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Kind"><span class="hs-identifier hs-type">Kind</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#FamilyResultSig"><span class="hs-identifier hs-type">FamilyResultSig</span></a></span><span>
</span><span id="line-302"></span><span id="kindSig"><span class="annot"><span class="annottext">kindSig :: Type -&gt; FamilyResultSig
</span><a href="Language.Haskell.TH.Lib.html#kindSig"><span class="hs-identifier hs-var hs-var">kindSig</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Type -&gt; FamilyResultSig
</span><a href="Language.Haskell.TH.Syntax.html#KindSig"><span class="hs-identifier hs-var">KindSig</span></a></span><span>
</span><span id="line-303"></span><span>
</span><span id="line-304"></span><span class="annot"><a href="Language.Haskell.TH.Lib.html#tyVarSig"><span class="hs-identifier hs-type">tyVarSig</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#TyVarBndr"><span class="hs-identifier hs-type">TyVarBndr</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#FamilyResultSig"><span class="hs-identifier hs-type">FamilyResultSig</span></a></span><span>
</span><span id="line-305"></span><span id="tyVarSig"><span class="annot"><span class="annottext">tyVarSig :: TyVarBndr () -&gt; FamilyResultSig
</span><a href="Language.Haskell.TH.Lib.html#tyVarSig"><span class="hs-identifier hs-var hs-var">tyVarSig</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">TyVarBndr () -&gt; FamilyResultSig
</span><a href="Language.Haskell.TH.Syntax.html#TyVarSig"><span class="hs-identifier hs-var">TyVarSig</span></a></span><span>
</span><span id="line-306"></span><span>
</span><span id="line-307"></span><span class="hs-comment">-------------------------------------------------------------------------------</span><span>
</span><span id="line-308"></span><span class="hs-comment">-- * Top Level Declarations</span><span>
</span><span id="line-309"></span><span>
</span><span id="line-310"></span><span id="local-6989586621679167665"><span class="annot"><a href="Language.Haskell.TH.Lib.html#derivClause"><span class="hs-identifier hs-type">derivClause</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167665"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#DerivStrategy"><span class="hs-identifier hs-type">DerivStrategy</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167665"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Pred"><span class="hs-identifier hs-type">Pred</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167665"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#DerivClause"><span class="hs-identifier hs-type">DerivClause</span></a></span></span><span>
</span><span id="line-311"></span><span id="derivClause"><span class="annot"><span class="annottext">derivClause :: forall (m :: * -&gt; *).
Quote m =&gt;
Maybe DerivStrategy -&gt; [m Type] -&gt; m DerivClause
</span><a href="Language.Haskell.TH.Lib.html#derivClause"><span class="hs-identifier hs-var hs-var">derivClause</span></a></span></span><span> </span><span id="local-6989586621679167328"><span class="annot"><span class="annottext">Maybe DerivStrategy
</span><a href="#local-6989586621679167328"><span class="hs-identifier hs-var">mds</span></a></span></span><span> </span><span id="local-6989586621679167327"><span class="annot"><span class="annottext">[m Type]
</span><a href="#local-6989586621679167327"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-312"></span><span>  </span><span id="local-6989586621679167326"><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679167326"><span class="hs-identifier hs-var">p'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m Type] -&gt; m Cxt
forall (m :: * -&gt; *). Quote m =&gt; [m Type] -&gt; m Cxt
</span><a href="Language.Haskell.TH.Lib.Internal.html#cxt"><span class="hs-identifier hs-var">cxt</span></a></span><span> </span><span class="annot"><span class="annottext">[m Type]
</span><a href="#local-6989586621679167327"><span class="hs-identifier hs-var">p</span></a></span><span>
</span><span id="line-313"></span><span>  </span><span class="annot"><span class="annottext">DerivClause -&gt; m DerivClause
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(DerivClause -&gt; m DerivClause) -&gt; DerivClause -&gt; m DerivClause
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe DerivStrategy -&gt; Cxt -&gt; DerivClause
</span><a href="Language.Haskell.TH.Syntax.html#DerivClause"><span class="hs-identifier hs-var">DerivClause</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe DerivStrategy
</span><a href="#local-6989586621679167328"><span class="hs-identifier hs-var">mds</span></a></span><span> </span><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679167326"><span class="hs-identifier hs-var">p'</span></a></span><span>
</span><span id="line-314"></span><span>
</span><span id="line-315"></span><span id="local-6989586621679167662"><span class="annot"><a href="Language.Haskell.TH.Lib.html#standaloneDerivWithStrategyD"><span class="hs-identifier hs-type">standaloneDerivWithStrategyD</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167662"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#DerivStrategy"><span class="hs-identifier hs-type">DerivStrategy</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167662"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Cxt"><span class="hs-identifier hs-type">Cxt</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167662"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Type"><span class="hs-identifier hs-type">Type</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167662"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Dec"><span class="hs-identifier hs-type">Dec</span></a></span></span><span>
</span><span id="line-316"></span><span id="standaloneDerivWithStrategyD"><span class="annot"><span class="annottext">standaloneDerivWithStrategyD :: forall (m :: * -&gt; *).
Quote m =&gt;
Maybe DerivStrategy -&gt; m Cxt -&gt; m Type -&gt; m Dec
</span><a href="Language.Haskell.TH.Lib.html#standaloneDerivWithStrategyD"><span class="hs-identifier hs-var hs-var">standaloneDerivWithStrategyD</span></a></span></span><span> </span><span id="local-6989586621679167319"><span class="annot"><span class="annottext">Maybe DerivStrategy
</span><a href="#local-6989586621679167319"><span class="hs-identifier hs-var">mds</span></a></span></span><span> </span><span id="local-6989586621679167318"><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679167318"><span class="hs-identifier hs-var">ctxt</span></a></span></span><span> </span><span id="local-6989586621679167317"><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679167317"><span class="hs-identifier hs-var">ty</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-317"></span><span>  </span><span id="local-6989586621679167316"><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679167316"><span class="hs-identifier hs-var">ctxt'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Cxt
</span><a href="#local-6989586621679167318"><span class="hs-identifier hs-var">ctxt</span></a></span><span>
</span><span id="line-318"></span><span>  </span><span id="local-6989586621679167315"><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679167315"><span class="hs-identifier hs-var">ty'</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">m Type
</span><a href="#local-6989586621679167317"><span class="hs-identifier hs-var">ty</span></a></span><span>
</span><span id="line-319"></span><span>  </span><span class="annot"><span class="annottext">Dec -&gt; m Dec
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Dec -&gt; m Dec) -&gt; Dec -&gt; m Dec
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe DerivStrategy -&gt; Cxt -&gt; Type -&gt; Dec
</span><a href="Language.Haskell.TH.Syntax.html#StandaloneDerivD"><span class="hs-identifier hs-var">StandaloneDerivD</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe DerivStrategy
</span><a href="#local-6989586621679167319"><span class="hs-identifier hs-var">mds</span></a></span><span> </span><span class="annot"><span class="annottext">Cxt
</span><a href="#local-6989586621679167316"><span class="hs-identifier hs-var">ctxt'</span></a></span><span> </span><span class="annot"><span class="annottext">Type
</span><a href="#local-6989586621679167315"><span class="hs-identifier hs-var">ty'</span></a></span><span>
</span><span id="line-320"></span><span>
</span><span id="line-321"></span><span class="hs-comment">-------------------------------------------------------------------------------</span><span>
</span><span id="line-322"></span><span class="hs-comment">-- * Bytes literals</span><span>
</span><span id="line-323"></span><span>
</span><span id="line-324"></span><span class="hs-comment">-- | Create a Bytes datatype representing raw bytes to be embedded into the</span><span>
</span><span id="line-325"></span><span class="hs-comment">-- program/library binary.</span><span>
</span><span id="line-326"></span><span class="hs-comment">--</span><span>
</span><span id="line-327"></span><span class="hs-comment">-- @since 2.16.0.0</span><span>
</span><span id="line-328"></span><span class="annot"><a href="Language.Haskell.TH.Lib.html#mkBytes"><span class="hs-identifier hs-type">mkBytes</span></a></span><span>
</span><span id="line-329"></span><span>   </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.ForeignPtr.html#ForeignPtr"><span class="hs-identifier hs-type">ForeignPtr</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span> </span><span class="hs-comment">-- ^ Pointer to the data</span><span>
</span><span id="line-330"></span><span>   </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Word"><span class="hs-identifier hs-type">Word</span></a></span><span>             </span><span class="hs-comment">-- ^ Offset from the pointer</span><span>
</span><span id="line-331"></span><span>   </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Word"><span class="hs-identifier hs-type">Word</span></a></span><span>             </span><span class="hs-comment">-- ^ Number of bytes</span><span>
</span><span id="line-332"></span><span>   </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Bytes"><span class="hs-identifier hs-type">Bytes</span></a></span><span>
</span><span id="line-333"></span><span id="mkBytes"><span class="annot"><span class="annottext">mkBytes :: ForeignPtr Word8 -&gt; Word -&gt; Word -&gt; Bytes
</span><a href="Language.Haskell.TH.Lib.html#mkBytes"><span class="hs-identifier hs-var hs-var">mkBytes</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ForeignPtr Word8 -&gt; Word -&gt; Word -&gt; Bytes
</span><a href="Language.Haskell.TH.Syntax.html#Bytes"><span class="hs-identifier hs-var">Bytes</span></a></span><span>
</span><span id="line-334"></span><span>
</span><span id="line-335"></span><span class="hs-comment">-------------------------------------------------------------------------------</span><span>
</span><span id="line-336"></span><span class="hs-comment">-- * Tuple expressions</span><span>
</span><span id="line-337"></span><span>
</span><span id="line-338"></span><span id="local-6989586621679167658"><span class="annot"><a href="Language.Haskell.TH.Lib.html#tupE"><span class="hs-identifier hs-type">tupE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167658"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167658"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167658"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-339"></span><span id="tupE"><span class="annot"><span class="annottext">tupE :: forall (m :: * -&gt; *). Quote m =&gt; [m Exp] -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.html#tupE"><span class="hs-identifier hs-var hs-var">tupE</span></a></span></span><span> </span><span id="local-6989586621679167305"><span class="annot"><span class="annottext">[m Exp]
</span><a href="#local-6989586621679167305"><span class="hs-identifier hs-var">es</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679167304"><span class="annot"><span class="annottext">[Exp]
</span><a href="#local-6989586621679167304"><span class="hs-identifier hs-var">es1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m Exp] -&gt; m [Exp]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m Exp]
</span><a href="#local-6989586621679167305"><span class="hs-identifier hs-var">es</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Maybe Exp] -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#TupE"><span class="hs-identifier hs-var">TupE</span></a></span><span> </span><span class="annot"><span class="annottext">([Maybe Exp] -&gt; Exp) -&gt; [Maybe Exp] -&gt; Exp
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">(Exp -&gt; Maybe Exp) -&gt; [Exp] -&gt; [Maybe Exp]
forall a b. (a -&gt; b) -&gt; [a] -&gt; [b]
</span><a href="../../base/src/GHC.Base.html#map"><span class="hs-identifier hs-var">map</span></a></span><span> </span><span class="annot"><span class="annottext">Exp -&gt; Maybe Exp
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="annot"><span class="annottext">[Exp]
</span><a href="#local-6989586621679167304"><span class="hs-identifier hs-var">es1</span></a></span><span class="hs-special">)</span><span class="hs-special">}</span><span>
</span><span id="line-340"></span><span>
</span><span id="line-341"></span><span id="local-6989586621679167302"><span class="annot"><a href="Language.Haskell.TH.Lib.html#unboxedTupE"><span class="hs-identifier hs-type">unboxedTupE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167302"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167302"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167302"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-342"></span><span id="unboxedTupE"><span class="annot"><span class="annottext">unboxedTupE :: forall (m :: * -&gt; *). Quote m =&gt; [m Exp] -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.html#unboxedTupE"><span class="hs-identifier hs-var hs-var">unboxedTupE</span></a></span></span><span> </span><span id="local-6989586621679167294"><span class="annot"><span class="annottext">[m Exp]
</span><a href="#local-6989586621679167294"><span class="hs-identifier hs-var">es</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679167293"><span class="annot"><span class="annottext">[Exp]
</span><a href="#local-6989586621679167293"><span class="hs-identifier hs-var">es1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[m Exp] -&gt; m [Exp]
forall (t :: * -&gt; *) (f :: * -&gt; *) a.
(Traversable t, Applicative f) =&gt;
t (f a) -&gt; f (t a)
</span><a href="../../base/src/Data.Traversable.html#sequenceA"><span class="hs-identifier hs-var">sequenceA</span></a></span><span> </span><span class="annot"><span class="annottext">[m Exp]
</span><a href="#local-6989586621679167294"><span class="hs-identifier hs-var">es</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Exp -&gt; m Exp
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">[Maybe Exp] -&gt; Exp
</span><a href="Language.Haskell.TH.Syntax.html#UnboxedTupE"><span class="hs-identifier hs-var">UnboxedTupE</span></a></span><span> </span><span class="annot"><span class="annottext">([Maybe Exp] -&gt; Exp) -&gt; [Maybe Exp] -&gt; Exp
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">(Exp -&gt; Maybe Exp) -&gt; [Exp] -&gt; [Maybe Exp]
forall a b. (a -&gt; b) -&gt; [a] -&gt; [b]
</span><a href="../../base/src/GHC.Base.html#map"><span class="hs-identifier hs-var">map</span></a></span><span> </span><span class="annot"><span class="annottext">Exp -&gt; Maybe Exp
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="annot"><span class="annottext">[Exp]
</span><a href="#local-6989586621679167293"><span class="hs-identifier hs-var">es1</span></a></span><span class="hs-special">)</span><span class="hs-special">}</span><span>
</span><span id="line-343"></span><span>
</span><span id="line-344"></span><span class="hs-comment">-------------------------------------------------------------------------------</span><span>
</span><span id="line-345"></span><span class="hs-comment">-- * Do expressions</span><span>
</span><span id="line-346"></span><span>
</span><span id="line-347"></span><span id="local-6989586621679167653"><span class="annot"><a href="Language.Haskell.TH.Lib.html#doE"><span class="hs-identifier hs-type">doE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167653"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167653"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Stmt"><span class="hs-identifier hs-type">Stmt</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167653"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-348"></span><span id="doE"><span class="annot"><span class="annottext">doE :: forall (m :: * -&gt; *). Quote m =&gt; [m Stmt] -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.html#doE"><span class="hs-identifier hs-var hs-var">doE</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Maybe ModName -&gt; [m Stmt] -&gt; m Exp
forall (m :: * -&gt; *). Quote m =&gt; Maybe ModName -&gt; [m Stmt] -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#doE"><span class="hs-identifier hs-var">Internal.doE</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe ModName
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-349"></span><span>
</span><span id="line-350"></span><span id="local-6989586621679167289"><span class="annot"><a href="Language.Haskell.TH.Lib.html#mdoE"><span class="hs-identifier hs-type">mdoE</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Quote"><span class="hs-identifier hs-type">Quote</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679167289"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679167289"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Stmt"><span class="hs-identifier hs-type">Stmt</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621679167289"><span class="hs-identifier hs-type">m</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Exp"><span class="hs-identifier hs-type">Exp</span></a></span></span><span>
</span><span id="line-351"></span><span id="mdoE"><span class="annot"><span class="annottext">mdoE :: forall (m :: * -&gt; *). Quote m =&gt; [m Stmt] -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.html#mdoE"><span class="hs-identifier hs-var hs-var">mdoE</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Maybe ModName -&gt; [m Stmt] -&gt; m Exp
forall (m :: * -&gt; *). Quote m =&gt; Maybe ModName -&gt; [m Stmt] -&gt; m Exp
</span><a href="Language.Haskell.TH.Lib.Internal.html#mdoE"><span class="hs-identifier hs-var">Internal.mdoE</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe ModName
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-352"></span></pre></body></html>